
#include "os_interface.h"

class MyIocService : public OSIoc
{
public:
    MyIocService() {}

     int init() override
    {
        m_dataBuffers = new uint8_t*[MAX_NUM_BUFFERS];
        for (int i = 0; i < MAX_NUM_BUFFERS; ++i)
        {
            m_dataBuffers[i] = new uint8_t[MAX_BUFFER_SIZE];
        }
        memset(m_dataSizes, 0, sizeof(int) * MAX_NUM_BUFFERS);

        m_paramBuffers = new uint8_t*[MAX_NUM_PARAMETERS];
        for (int i = 0; i < MAX_NUM_PARAMETERS; ++i)
        {
            m_paramBuffers[i] = new uint8_t[MAX_BUFFER_SIZE];
        }
        memset(m_paramSizes, 0, sizeof(int) * MAX_NUM_PARAMETERS);

        return 0;
    }

     int deinit() override
    {
        for (int i = 0; i < MAX_NUM_BUFFERS; ++i)
        {
            delete[] m_dataBuffers[i];
        }
        delete[] m_dataBuffers;

        for (int i = 0; i < MAX_NUM_PARAMETERS; ++i)
        {
            delete[] m_paramBuffers[i];
        }
        delete[] m_paramBuffers;

        delete[] m_dataSizes;
        delete[] m_paramSizes;

        return 0;
    }

     int start() override
    {
        if (m_isRunning)
        {
            return -1;
        }

        m_isRunning = true;
        return 0;
    }

     int stop() override
    {
        if (!m_isRunning)
        {
            return -1;
        }

        m_isRunning = false;
        return 0;
    }

     int read(int index, void* buffer, int maxSize) override
    {
        if (maxSize < m_dataSizes[index])
        {
            return -1;
        }

        memcpy(buffer, m_dataBuffers[index], m_dataSizes[index]);
        memset(m_dataBuffers[index], 0, sizeof(uint8_t) * m_dataSizes[index]);
        m_dataSizes[index] = 0;

        return m_dataSizes[index];
    }

     int write(int index, const void* buffer, int size) override
    {
        if (size > MAX_BUFFER_SIZE)
        {
            size = MAX_BUFFER_SIZE;
        }

        memcpy(m_dataBuffers[index], buffer, size);
        m_dataSizes[index] = size;

        return size;
    }

     int setParameter(int index, const void* value, int size) override
    {
        if (size > MAX_BUFFER_SIZE)
        {
            size = MAX_BUFFER_SIZE;
        }

        memcpy(m_paramBuffers[index], value, size);
        m_paramSizes[index] = size;

        return size;
    }

     int getParameter(int index, void* buffer, int maxSize) override
    {
        if (maxSize < m_paramSizes[index])
        {
            return -1;
        }

        memcpy(buffer, m_paramBuffers[index], m_paramSizes[index]);
        memset(m_paramBuffers[index], 0, sizeof(uint8_t) * m_paramSizes[index]);
        m_paramSizes[index] = 0;

        return m_paramSizes[index];
    }

private:
    const int MAX_NUM_BUFFERS = 10;    //最大buffer缓冲长度
    const int MAX_NUM_PARAMETERS = 5;     // BUffer缓冲区的个数
    const int MAX_BUFFER_SIZE = 1024;   //   最大buffer缓冲长度

    bool m_isRunning = false;   // 正在运行

    uint8_t** m_dataBuffers;
    uint8_t** m_paramBuffers;
    int* m_dataSizes = new int[MAX_NUM_BUFFERS];
    int* m_paramSizes = new int[MAX_NUM_PARAMETERS];
};
 

// 在这个示例中，我们假设服务可以并发地进行读写操作并应对多任务环境。
// 我们使用了多个数据缓冲区和参数缓冲区，每个缓冲区都可以被不同的任务调用。
// 在`init`函数中，我们为每个缓冲区分配了一个 `MAX_BUFFER_SIZE` 字节大小的内存块。
// 在`read`函数中，我们检查用户提供的缓冲区的大小，如果不足以存储请求的数据，则返回错误。
// 在`write`函数中，我们检查用户提供的数据的大小，如果超过 `MAX_BUFFER_SIZE`，则将其缩小为 `MAX_BUFFER_SIZE`。
// 在`setParameter`函数中，我们执行类似的大小检查操作。在`getParameter`函数中，我们检查用户提供的缓冲区的大小，
// 如果不足以存储请求的参数，则返回错误。在所有读写和设置参数的操作中，我们算法地释放已经使用的缓冲区，并在参数缓冲区处存储新的参数值。

// 需要注意的是，在实际的应用中，我们可能需要使用特定的缓冲区排队方案或消息传递方式来处理并发操作
// 。同时，我们还需要考虑数据同步和数据保护机制，以确保数据的正确性和一致性。 
 